The Rust Programming Language: Project Blueprint: Building a Rust-Powered Grep

In the world of Rust, a robust CLI tool isn't just a single script; it is a carefully orchestrated Project Blueprint. To build a tool like grep, we divide our labor between a Binary Crate and a Library Crate.

1. The Coffee Machine Metaphor

Think of a high-end coffee machine. The lib.rs contains the internal mechanisms for heating water and grinding beans—the "engine logic." The main.rs is the external button the user presses—the "interface." By keeping them separate, a technician can test the heater (library) without having to press the physical button (binary) every single time.

2. Scaffolding the Engine

We begin with $ cargo new minigrep. While this creates a main.rs, we must manually introduce src/lib.rs. This architectural split ensures our core search logic remains decoupled from the CLI parsing, enabling easier testing and modularity.

3. Testable Modularity

By moving logic to lib.rs, we utilize Rust’s testing framework to call library functions in a controlled environment. We use use minigrep; in our binary to import the engine while keeping the command-line parsing logic isolated.

TERMINAL bash — 80x24

> Ready. Click "Run" to execute.

QUESTION 1

Which file in a Rust project typically serves as the executable entry point?

$src/lib.rs$

src/main.rs

Cargo.toml

$src/bin.rs$

QUESTION 2

Why refactor logic from main.rs into lib.rs?

To make the code run faster.

To enable easier unit testing and modularity.

Because Rust does not allow more than 100 lines in main.rs.

To prevent Cargo from compiling the binary.

QUESTION 3

Which terminal command initializes a new Rust package named 'minigrep'?

cargo start minigrep

$ cargo new minigrep

rustc minigrep --init

cargo build minigrep

QUESTION 4

What keyword is required in lib.rs to make a function accessible to main.rs?

extern

open

pub

crate

QUESTION 5

In the coffee machine analogy, what does the 'ignition switch' represent?

The Library Crate (src/lib.rs)

The Binary Crate (src/main.rs)

The Cargo.lock file

The Testing Module

Case Study: The Grep Refactor

Modularizing a Search Tool

You have a single main.rs file that handles argument parsing, file reading, and string searching. It is becoming hard to maintain. You decide to move the search logic to a library crate to implement TDD.

1. What code snippet would you write at the top of src/main.rs to access functions from src/lib.rs?

Solution:
You would use use minigrep; (assuming the package name is minigrep) to bring the library's public API into the binary's scope.

2. How would you structure a test in src/lib.rs to verify the search logic?

Solution:
Using the #[cfg(test)] attribute and a mod tests block, you can call super::search() and assert_eq!() to verify results.

3. If src/lib.rs contains 'fn run()', how must it be declared for main.rs to use it?

Solution:
It must be declared as pub fn run(). Without the pub keyword, it remains private to the library crate.